(function (f) {
  if (typeof exports === "object" && typeof module !== "undefined") {
    module.exports = f();
  } else if (typeof define === "function" && define.amd) {
    define([], f);
  } else {
    var g;
    if (typeof window !== "undefined") {
      g = window;
    } else if (typeof global !== "undefined") {
      g = global;
    } else if (typeof self !== "undefined") {
      g = self;
    } else {
      g = this;
    }
    g.PropTypes = f();
  }
})(function () {
  var define, module, exports;
  return (function e(t, n, r) {
    function s(o, u) {
      if (!n[o]) {
        if (!t[o]) {
          var a = typeof require == "function" && require;
          if (!u && a) return a(o, !0);
          if (i) return i(o, !0);
          var f = new Error("Cannot find module '" + o + "'");
          throw ((f.code = "MODULE_NOT_FOUND"), f);
        }
        var l = (n[o] = { exports: {} });
        t[o][0].call(
          l.exports,
          function (e) {
            var n = t[o][1][e];
            return s(n ? n : e);
          },
          l,
          l.exports,
          e,
          t,
          n,
          r
        );
      }
      return n[o].exports;
    }
    var i = typeof require == "function" && require;
    for (var o = 0; o < r.length; o++) s(r[o]);
    return s;
  })(
    {
      1: [
        function (require, module, exports) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           *
           * This source code is licensed under the MIT license found in the
           * LICENSE file in the root directory of this source tree.
           */

          "use strict";

          var printWarning = function () {};

          if ("development" !== "production") {
            var ReactPropTypesSecret = require("./lib/ReactPropTypesSecret");
            var loggedTypeFailures = {};
            var has = Function.call.bind(Object.prototype.hasOwnProperty);

            printWarning = function (text) {
              var message = "Warning: " + text;
              if (typeof console !== "undefined") {
                console.error(message);
              }
              try {
                // --- Welcome to debugging React ---
                // This error was thrown as a convenience so that you can use this stack
                // to find the callsite that caused this warning to fire.
                throw new Error(message);
              } catch (x) {}
            };
          }

          /**
           * Assert that the values match with the type specs.
           * Error messages are memorized and will only be shown once.
           *
           * @param {object} typeSpecs Map of name to a ReactPropType
           * @param {object} values Runtime values that need to be type-checked
           * @param {string} location e.g. "prop", "context", "child context"
           * @param {string} componentName Name of the component for error messages.
           * @param {?Function} getStack Returns the component stack.
           * @private
           */
          function checkPropTypes(
            typeSpecs,
            values,
            location,
            componentName,
            getStack
          ) {
            if ("development" !== "production") {
              for (var typeSpecName in typeSpecs) {
                if (has(typeSpecs, typeSpecName)) {
                  var error;
                  // Prop type validation may throw. In case they do, we don't want to
                  // fail the render phase where it didn't fail before. So we log it.
                  // After these have been cleaned up, we'll let them throw.
                  try {
                    // This is intentionally an invariant that gets caught. It's the same
                    // behavior as without this statement except with a better message.
                    if (typeof typeSpecs[typeSpecName] !== "function") {
                      var err = Error(
                        (componentName || "React class") +
                          ": " +
                          location +
                          " type `" +
                          typeSpecName +
                          "` is invalid; " +
                          "it must be a function, usually from the `prop-types` package, but received `" +
                          typeof typeSpecs[typeSpecName] +
                          "`."
                      );
                      err.name = "Invariant Violation";
                      throw err;
                    }
                    error = typeSpecs[typeSpecName](
                      values,
                      typeSpecName,
                      componentName,
                      location,
                      null,
                      ReactPropTypesSecret
                    );
                  } catch (ex) {
                    error = ex;
                  }
                  if (error && !(error instanceof Error)) {
                    printWarning(
                      (componentName || "React class") +
                        ": type specification of " +
                        location +
                        " `" +
                        typeSpecName +
                        "` is invalid; the type checker " +
                        "function must return `null` or an `Error` but returned a " +
                        typeof error +
                        ". " +
                        "You may have forgotten to pass an argument to the type checker " +
                        "creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and " +
                        "shape all require an argument)."
                    );
                  }
                  if (
                    error instanceof Error &&
                    !(error.message in loggedTypeFailures)
                  ) {
                    // Only monitor this failure once because there tends to be a lot of the
                    // same error.
                    loggedTypeFailures[error.message] = true;

                    var stack = getStack ? getStack() : "";

                    printWarning(
                      "Failed " +
                        location +
                        " type: " +
                        error.message +
                        (stack != null ? stack : "")
                    );
                  }
                }
              }
            }
          }

          /**
           * Resets warning cache when testing.
           *
           * @private
           */
          checkPropTypes.resetWarningCache = function () {
            if ("development" !== "production") {
              loggedTypeFailures = {};
            }
          };

          module.exports = checkPropTypes;
        },
        { "./lib/ReactPropTypesSecret": 5 },
      ],
      2: [
        function (require, module, exports) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           *
           * This source code is licensed under the MIT license found in the
           * LICENSE file in the root directory of this source tree.
           */

          "use strict";

          var ReactPropTypesSecret = require("./lib/ReactPropTypesSecret");

          function emptyFunction() {}
          function emptyFunctionWithReset() {}
          emptyFunctionWithReset.resetWarningCache = emptyFunction;

          module.exports = function () {
            function shim(
              props,
              propName,
              componentName,
              location,
              propFullName,
              secret
            ) {
              if (secret === ReactPropTypesSecret) {
                // It is still safe when called from React.
                return;
              }
              var err = new Error(
                "Calling PropTypes validators directly is not supported by the `prop-types` package. " +
                  "Use PropTypes.checkPropTypes() to call them. " +
                  "Read more at http://fb.me/use-check-prop-types"
              );
              err.name = "Invariant Violation";
              throw err;
            }
            shim.isRequired = shim;
            function getShim() {
              return shim;
            }
            // Important!
            // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
            var ReactPropTypes = {
              array: shim,
              bool: shim,
              func: shim,
              number: shim,
              object: shim,
              string: shim,
              symbol: shim,

              any: shim,
              arrayOf: getShim,
              element: shim,
              elementType: shim,
              instanceOf: getShim,
              node: shim,
              objectOf: getShim,
              oneOf: getShim,
              oneOfType: getShim,
              shape: getShim,
              exact: getShim,

              checkPropTypes: emptyFunctionWithReset,
              resetWarningCache: emptyFunction,
            };

            ReactPropTypes.PropTypes = ReactPropTypes;

            return ReactPropTypes;
          };
        },
        { "./lib/ReactPropTypesSecret": 5 },
      ],
      3: [
        function (require, module, exports) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           *
           * This source code is licensed under the MIT license found in the
           * LICENSE file in the root directory of this source tree.
           */

          "use strict";

          var ReactIs = require("react-is");
          var assign = require("object-assign");

          var ReactPropTypesSecret = require("./lib/ReactPropTypesSecret");
          var checkPropTypes = require("./checkPropTypes");

          var has = Function.call.bind(Object.prototype.hasOwnProperty);
          var printWarning = function () {};

          if ("development" !== "production") {
            printWarning = function (text) {
              var message = "Warning: " + text;
              if (typeof console !== "undefined") {
                console.error(message);
              }
              try {
                // --- Welcome to debugging React ---
                // This error was thrown as a convenience so that you can use this stack
                // to find the callsite that caused this warning to fire.
                throw new Error(message);
              } catch (x) {}
            };
          }

          function emptyFunctionThatReturnsNull() {
            return null;
          }

          module.exports = function (isValidElement, throwOnDirectAccess) {
            /* global Symbol */
            var ITERATOR_SYMBOL =
              typeof Symbol === "function" && Symbol.iterator;
            var FAUX_ITERATOR_SYMBOL = "@@iterator"; // Before Symbol spec.

            /**
             * Returns the iterator method function contained on the iterable object.
             *
             * Be sure to invoke the function with the iterable as context:
             *
             *     var iteratorFn = getIteratorFn(myIterable);
             *     if (iteratorFn) {
             *       var iterator = iteratorFn.call(myIterable);
             *       ...
             *     }
             *
             * @param {?object} maybeIterable
             * @return {?function}
             */
            function getIteratorFn(maybeIterable) {
              var iteratorFn =
                maybeIterable &&
                ((ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL]) ||
                  maybeIterable[FAUX_ITERATOR_SYMBOL]);
              if (typeof iteratorFn === "function") {
                return iteratorFn;
              }
            }

            /**
             * Collection of methods that allow declaration and validation of props that are
             * supplied to React components. Example usage:
             *
             *   var Props = require('ReactPropTypes');
             *   var MyArticle = React.createClass({
             *     propTypes: {
             *       // An optional string prop named "description".
             *       description: Props.string,
             *
             *       // A required enum prop named "category".
             *       category: Props.oneOf(['News','Photos']).isRequired,
             *
             *       // A prop named "dialog" that requires an instance of Dialog.
             *       dialog: Props.instanceOf(Dialog).isRequired
             *     },
             *     render: function() { ... }
             *   });
             *
             * A more formal specification of how these methods are used:
             *
             *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
             *   decl := ReactPropTypes.{type}(.isRequired)?
             *
             * Each and every declaration produces a function with the same signature. This
             * allows the creation of custom validation functions. For example:
             *
             *  var MyLink = React.createClass({
             *    propTypes: {
             *      // An optional string or URI prop named "href".
             *      href: function(props, propName, componentName) {
             *        var propValue = props[propName];
             *        if (propValue != null && typeof propValue !== 'string' &&
             *            !(propValue instanceof URI)) {
             *          return new Error(
             *            'Expected a string or an URI for ' + propName + ' in ' +
             *            componentName
             *          );
             *        }
             *      }
             *    },
             *    render: function() {...}
             *  });
             *
             * @internal
             */

            var ANONYMOUS = "<<anonymous>>";

            // Important!
            // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
            var ReactPropTypes = {
              array: createPrimitiveTypeChecker("array"),
              bool: createPrimitiveTypeChecker("boolean"),
              func: createPrimitiveTypeChecker("function"),
              number: createPrimitiveTypeChecker("number"),
              object: createPrimitiveTypeChecker("object"),
              string: createPrimitiveTypeChecker("string"),
              symbol: createPrimitiveTypeChecker("symbol"),

              any: createAnyTypeChecker(),
              arrayOf: createArrayOfTypeChecker,
              element: createElementTypeChecker(),
              elementType: createElementTypeTypeChecker(),
              instanceOf: createInstanceTypeChecker,
              node: createNodeChecker(),
              objectOf: createObjectOfTypeChecker,
              oneOf: createEnumTypeChecker,
              oneOfType: createUnionTypeChecker,
              shape: createShapeTypeChecker,
              exact: createStrictShapeTypeChecker,
            };

            /**
             * inlined Object.is polyfill to avoid requiring consumers ship their own
             * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
             */
            /*eslint-disable no-self-compare*/
            function is(x, y) {
              // SameValue algorithm
              if (x === y) {
                // Steps 1-5, 7-10
                // Steps 6.b-6.e: +0 != -0
                return x !== 0 || 1 / x === 1 / y;
              } else {
                // Step 6.a: NaN == NaN
                return x !== x && y !== y;
              }
            }
            /*eslint-enable no-self-compare*/

            /**
             * We use an Error-like object for backward compatibility as people may call
             * PropTypes directly and inspect their output. However, we don't use real
             * Errors anymore. We don't inspect their stack anyway, and creating them
             * is prohibitively expensive if they are created too often, such as what
             * happens in oneOfType() for any type before the one that matched.
             */
            function PropTypeError(message) {
              this.message = message;
              this.stack = "";
            }
            // Make `instanceof Error` still work for returned errors.
            PropTypeError.prototype = Error.prototype;

            function createChainableTypeChecker(validate) {
              if ("development" !== "production") {
                var manualPropTypeCallCache = {};
                var manualPropTypeWarningCount = 0;
              }
              function checkType(
                isRequired,
                props,
                propName,
                componentName,
                location,
                propFullName,
                secret
              ) {
                componentName = componentName || ANONYMOUS;
                propFullName = propFullName || propName;

                if (secret !== ReactPropTypesSecret) {
                  if (throwOnDirectAccess) {
                    // New behavior only for users of `prop-types` package
                    var err = new Error(
                      "Calling PropTypes validators directly is not supported by the `prop-types` package. " +
                        "Use `PropTypes.checkPropTypes()` to call them. " +
                        "Read more at http://fb.me/use-check-prop-types"
                    );
                    err.name = "Invariant Violation";
                    throw err;
                  } else if (
                    "development" !== "production" &&
                    typeof console !== "undefined"
                  ) {
                    // Old behavior for people using React.PropTypes
                    var cacheKey = componentName + ":" + propName;
                    if (
                      !manualPropTypeCallCache[cacheKey] &&
                      // Avoid spamming the console because they are often not actionable except for lib authors
                      manualPropTypeWarningCount < 3
                    ) {
                      printWarning(
                        "You are manually calling a React.PropTypes validation " +
                          "function for the `" +
                          propFullName +
                          "` prop on `" +
                          componentName +
                          "`. This is deprecated " +
                          "and will throw in the standalone `prop-types` package. " +
                          "You may be seeing this warning due to a third-party PropTypes " +
                          "library. See https://fb.me/react-warning-dont-call-proptypes " +
                          "for details."
                      );
                      manualPropTypeCallCache[cacheKey] = true;
                      manualPropTypeWarningCount++;
                    }
                  }
                }
                if (props[propName] == null) {
                  if (isRequired) {
                    if (props[propName] === null) {
                      return new PropTypeError(
                        "The " +
                          location +
                          " `" +
                          propFullName +
                          "` is marked as required " +
                          ("in `" +
                            componentName +
                            "`, but its value is `null`.")
                      );
                    }
                    return new PropTypeError(
                      "The " +
                        location +
                        " `" +
                        propFullName +
                        "` is marked as required in " +
                        ("`" +
                          componentName +
                          "`, but its value is `undefined`.")
                    );
                  }
                  return null;
                } else {
                  return validate(
                    props,
                    propName,
                    componentName,
                    location,
                    propFullName
                  );
                }
              }

              var chainedCheckType = checkType.bind(null, false);
              chainedCheckType.isRequired = checkType.bind(null, true);

              return chainedCheckType;
            }

            function createPrimitiveTypeChecker(expectedType) {
              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName,
                secret
              ) {
                var propValue = props[propName];
                var propType = getPropType(propValue);
                if (propType !== expectedType) {
                  // `propValue` being instance of, say, date/regexp, pass the 'object'
                  // check, but we can offer a more precise error message here rather than
                  // 'of type `object`'.
                  var preciseType = getPreciseType(propValue);

                  return new PropTypeError(
                    "Invalid " +
                      location +
                      " `" +
                      propFullName +
                      "` of type " +
                      ("`" +
                        preciseType +
                        "` supplied to `" +
                        componentName +
                        "`, expected ") +
                      ("`" + expectedType + "`.")
                  );
                }
                return null;
              }
              return createChainableTypeChecker(validate);
            }

            function createAnyTypeChecker() {
              return createChainableTypeChecker(emptyFunctionThatReturnsNull);
            }

            function createArrayOfTypeChecker(typeChecker) {
              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                if (typeof typeChecker !== "function") {
                  return new PropTypeError(
                    "Property `" +
                      propFullName +
                      "` of component `" +
                      componentName +
                      "` has invalid PropType notation inside arrayOf."
                  );
                }
                var propValue = props[propName];
                if (!Array.isArray(propValue)) {
                  var propType = getPropType(propValue);
                  return new PropTypeError(
                    "Invalid " +
                      location +
                      " `" +
                      propFullName +
                      "` of type " +
                      ("`" +
                        propType +
                        "` supplied to `" +
                        componentName +
                        "`, expected an array.")
                  );
                }
                for (var i = 0; i < propValue.length; i++) {
                  var error = typeChecker(
                    propValue,
                    i,
                    componentName,
                    location,
                    propFullName + "[" + i + "]",
                    ReactPropTypesSecret
                  );
                  if (error instanceof Error) {
                    return error;
                  }
                }
                return null;
              }
              return createChainableTypeChecker(validate);
            }

            function createElementTypeChecker() {
              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                var propValue = props[propName];
                if (!isValidElement(propValue)) {
                  var propType = getPropType(propValue);
                  return new PropTypeError(
                    "Invalid " +
                      location +
                      " `" +
                      propFullName +
                      "` of type " +
                      ("`" +
                        propType +
                        "` supplied to `" +
                        componentName +
                        "`, expected a single ReactElement.")
                  );
                }
                return null;
              }
              return createChainableTypeChecker(validate);
            }

            function createElementTypeTypeChecker() {
              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                var propValue = props[propName];
                if (!ReactIs.isValidElementType(propValue)) {
                  var propType = getPropType(propValue);
                  return new PropTypeError(
                    "Invalid " +
                      location +
                      " `" +
                      propFullName +
                      "` of type " +
                      ("`" +
                        propType +
                        "` supplied to `" +
                        componentName +
                        "`, expected a single ReactElement type.")
                  );
                }
                return null;
              }
              return createChainableTypeChecker(validate);
            }

            function createInstanceTypeChecker(expectedClass) {
              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                if (!(props[propName] instanceof expectedClass)) {
                  var expectedClassName = expectedClass.name || ANONYMOUS;
                  var actualClassName = getClassName(props[propName]);
                  return new PropTypeError(
                    "Invalid " +
                      location +
                      " `" +
                      propFullName +
                      "` of type " +
                      ("`" +
                        actualClassName +
                        "` supplied to `" +
                        componentName +
                        "`, expected ") +
                      ("instance of `" + expectedClassName + "`.")
                  );
                }
                return null;
              }
              return createChainableTypeChecker(validate);
            }

            function createEnumTypeChecker(expectedValues) {
              if (!Array.isArray(expectedValues)) {
                if ("development" !== "production") {
                  if (arguments.length > 1) {
                    printWarning(
                      "Invalid arguments supplied to oneOf, expected an array, got " +
                        arguments.length +
                        " arguments. " +
                        "A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
                    );
                  } else {
                    printWarning(
                      "Invalid argument supplied to oneOf, expected an array."
                    );
                  }
                }
                return emptyFunctionThatReturnsNull;
              }

              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                var propValue = props[propName];
                for (var i = 0; i < expectedValues.length; i++) {
                  if (is(propValue, expectedValues[i])) {
                    return null;
                  }
                }

                var valuesString = JSON.stringify(
                  expectedValues,
                  function replacer(key, value) {
                    var type = getPreciseType(value);
                    if (type === "symbol") {
                      return String(value);
                    }
                    return value;
                  }
                );
                return new PropTypeError(
                  "Invalid " +
                    location +
                    " `" +
                    propFullName +
                    "` of value `" +
                    String(propValue) +
                    "` " +
                    ("supplied to `" +
                      componentName +
                      "`, expected one of " +
                      valuesString +
                      ".")
                );
              }
              return createChainableTypeChecker(validate);
            }

            function createObjectOfTypeChecker(typeChecker) {
              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                if (typeof typeChecker !== "function") {
                  return new PropTypeError(
                    "Property `" +
                      propFullName +
                      "` of component `" +
                      componentName +
                      "` has invalid PropType notation inside objectOf."
                  );
                }
                var propValue = props[propName];
                var propType = getPropType(propValue);
                if (propType !== "object") {
                  return new PropTypeError(
                    "Invalid " +
                      location +
                      " `" +
                      propFullName +
                      "` of type " +
                      ("`" +
                        propType +
                        "` supplied to `" +
                        componentName +
                        "`, expected an object.")
                  );
                }
                for (var key in propValue) {
                  if (has(propValue, key)) {
                    var error = typeChecker(
                      propValue,
                      key,
                      componentName,
                      location,
                      propFullName + "." + key,
                      ReactPropTypesSecret
                    );
                    if (error instanceof Error) {
                      return error;
                    }
                  }
                }
                return null;
              }
              return createChainableTypeChecker(validate);
            }

            function createUnionTypeChecker(arrayOfTypeCheckers) {
              if (!Array.isArray(arrayOfTypeCheckers)) {
                "development" !== "production"
                  ? printWarning(
                      "Invalid argument supplied to oneOfType, expected an instance of array."
                    )
                  : void 0;
                return emptyFunctionThatReturnsNull;
              }

              for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
                var checker = arrayOfTypeCheckers[i];
                if (typeof checker !== "function") {
                  printWarning(
                    "Invalid argument supplied to oneOfType. Expected an array of check functions, but " +
                      "received " +
                      getPostfixForTypeWarning(checker) +
                      " at index " +
                      i +
                      "."
                  );
                  return emptyFunctionThatReturnsNull;
                }
              }

              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
                  var checker = arrayOfTypeCheckers[i];
                  if (
                    checker(
                      props,
                      propName,
                      componentName,
                      location,
                      propFullName,
                      ReactPropTypesSecret
                    ) == null
                  ) {
                    return null;
                  }
                }

                return new PropTypeError(
                  "Invalid " +
                    location +
                    " `" +
                    propFullName +
                    "` supplied to " +
                    ("`" + componentName + "`.")
                );
              }
              return createChainableTypeChecker(validate);
            }

            function createNodeChecker() {
              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                if (!isNode(props[propName])) {
                  return new PropTypeError(
                    "Invalid " +
                      location +
                      " `" +
                      propFullName +
                      "` supplied to " +
                      ("`" + componentName + "`, expected a ReactNode.")
                  );
                }
                return null;
              }
              return createChainableTypeChecker(validate);
            }

            function createShapeTypeChecker(shapeTypes) {
              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                var propValue = props[propName];
                var propType = getPropType(propValue);
                if (propType !== "object") {
                  return new PropTypeError(
                    "Invalid " +
                      location +
                      " `" +
                      propFullName +
                      "` of type `" +
                      propType +
                      "` " +
                      ("supplied to `" +
                        componentName +
                        "`, expected `object`.")
                  );
                }
                for (var key in shapeTypes) {
                  var checker = shapeTypes[key];
                  if (!checker) {
                    continue;
                  }
                  var error = checker(
                    propValue,
                    key,
                    componentName,
                    location,
                    propFullName + "." + key,
                    ReactPropTypesSecret
                  );
                  if (error) {
                    return error;
                  }
                }
                return null;
              }
              return createChainableTypeChecker(validate);
            }

            function createStrictShapeTypeChecker(shapeTypes) {
              function validate(
                props,
                propName,
                componentName,
                location,
                propFullName
              ) {
                var propValue = props[propName];
                var propType = getPropType(propValue);
                if (propType !== "object") {
                  return new PropTypeError(
                    "Invalid " +
                      location +
                      " `" +
                      propFullName +
                      "` of type `" +
                      propType +
                      "` " +
                      ("supplied to `" +
                        componentName +
                        "`, expected `object`.")
                  );
                }
                // We need to check all keys in case some are required but missing from
                // props.
                var allKeys = assign({}, props[propName], shapeTypes);
                for (var key in allKeys) {
                  var checker = shapeTypes[key];
                  if (!checker) {
                    return new PropTypeError(
                      "Invalid " +
                        location +
                        " `" +
                        propFullName +
                        "` key `" +
                        key +
                        "` supplied to `" +
                        componentName +
                        "`." +
                        "\nBad object: " +
                        JSON.stringify(props[propName], null, "  ") +
                        "\nValid keys: " +
                        JSON.stringify(Object.keys(shapeTypes), null, "  ")
                    );
                  }
                  var error = checker(
                    propValue,
                    key,
                    componentName,
                    location,
                    propFullName + "." + key,
                    ReactPropTypesSecret
                  );
                  if (error) {
                    return error;
                  }
                }
                return null;
              }

              return createChainableTypeChecker(validate);
            }

            function isNode(propValue) {
              switch (typeof propValue) {
                case "number":
                case "string":
                case "undefined":
                  return true;
                case "boolean":
                  return !propValue;
                case "object":
                  if (Array.isArray(propValue)) {
                    return propValue.every(isNode);
                  }
                  if (propValue === null || isValidElement(propValue)) {
                    return true;
                  }

                  var iteratorFn = getIteratorFn(propValue);
                  if (iteratorFn) {
                    var iterator = iteratorFn.call(propValue);
                    var step;
                    if (iteratorFn !== propValue.entries) {
                      while (!(step = iterator.next()).done) {
                        if (!isNode(step.value)) {
                          return false;
                        }
                      }
                    } else {
                      // Iterator will provide entry [k,v] tuples rather than values.
                      while (!(step = iterator.next()).done) {
                        var entry = step.value;
                        if (entry) {
                          if (!isNode(entry[1])) {
                            return false;
                          }
                        }
                      }
                    }
                  } else {
                    return false;
                  }

                  return true;
                default:
                  return false;
              }
            }

            function isSymbol(propType, propValue) {
              // Native Symbol.
              if (propType === "symbol") {
                return true;
              }

              // falsy value can't be a Symbol
              if (!propValue) {
                return false;
              }

              // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
              if (propValue["@@toStringTag"] === "Symbol") {
                return true;
              }

              // Fallback for non-spec compliant Symbols which are polyfilled.
              if (typeof Symbol === "function" && propValue instanceof Symbol) {
                return true;
              }

              return false;
            }

            // Equivalent of `typeof` but with special handling for array and regexp.
            function getPropType(propValue) {
              var propType = typeof propValue;
              if (Array.isArray(propValue)) {
                return "array";
              }
              if (propValue instanceof RegExp) {
                // Old webkits (at least until Android 4.0) return 'function' rather than
                // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
                // passes PropTypes.object.
                return "object";
              }
              if (isSymbol(propType, propValue)) {
                return "symbol";
              }
              return propType;
            }

            // This handles more types than `getPropType`. Only used for error messages.
            // See `createPrimitiveTypeChecker`.
            function getPreciseType(propValue) {
              if (typeof propValue === "undefined" || propValue === null) {
                return "" + propValue;
              }
              var propType = getPropType(propValue);
              if (propType === "object") {
                if (propValue instanceof Date) {
                  return "date";
                } else if (propValue instanceof RegExp) {
                  return "regexp";
                }
              }
              return propType;
            }

            // Returns a string that is postfixed to a warning about an invalid type.
            // For example, "undefined" or "of type array"
            function getPostfixForTypeWarning(value) {
              var type = getPreciseType(value);
              switch (type) {
                case "array":
                case "object":
                  return "an " + type;
                case "boolean":
                case "date":
                case "regexp":
                  return "a " + type;
                default:
                  return type;
              }
            }

            // Returns class name of the object, if any.
            function getClassName(propValue) {
              if (!propValue.constructor || !propValue.constructor.name) {
                return ANONYMOUS;
              }
              return propValue.constructor.name;
            }

            ReactPropTypes.checkPropTypes = checkPropTypes;
            ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
            ReactPropTypes.PropTypes = ReactPropTypes;

            return ReactPropTypes;
          };
        },
        {
          "./checkPropTypes": 1,
          "./lib/ReactPropTypesSecret": 5,
          "object-assign": 6,
          "react-is": 10,
        },
      ],
      4: [
        function (require, module, exports) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           *
           * This source code is licensed under the MIT license found in the
           * LICENSE file in the root directory of this source tree.
           */

          if ("development" !== "production") {
            var ReactIs = require("react-is");

            // By explicitly using `prop-types` you are opting into new development behavior.
            // http://fb.me/prop-types-in-prod
            var throwOnDirectAccess = true;
            module.exports = require("./factoryWithTypeCheckers")(
              ReactIs.isElement,
              throwOnDirectAccess
            );
          } else {
            // By explicitly using `prop-types` you are opting into new production behavior.
            // http://fb.me/prop-types-in-prod
            module.exports = require("./factoryWithThrowingShims")();
          }
        },
        {
          "./factoryWithThrowingShims": 2,
          "./factoryWithTypeCheckers": 3,
          "react-is": 10,
        },
      ],
      5: [
        function (require, module, exports) {
          /**
           * Copyright (c) 2013-present, Facebook, Inc.
           *
           * This source code is licensed under the MIT license found in the
           * LICENSE file in the root directory of this source tree.
           */

          "use strict";

          var ReactPropTypesSecret =
            "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";

          module.exports = ReactPropTypesSecret;
        },
        {},
      ],
      6: [
        function (require, module, exports) {
          /*
object-assign
(c) Sindre Sorhus
@license MIT
*/

          "use strict";
          /* eslint-disable no-unused-vars */
          var getOwnPropertySymbols = Object.getOwnPropertySymbols;
          var hasOwnProperty = Object.prototype.hasOwnProperty;
          var propIsEnumerable = Object.prototype.propertyIsEnumerable;

          function toObject(val) {
            if (val === null || val === undefined) {
              throw new TypeError(
                "Object.assign cannot be called with null or undefined"
              );
            }

            return Object(val);
          }

          function shouldUseNative() {
            try {
              if (!Object.assign) {
                return false;
              }

              // Detect buggy property enumeration order in older V8 versions.

              // https://bugs.chromium.org/p/v8/issues/detail?id=4118
              var test1 = new String("abc"); // eslint-disable-line no-new-wrappers
              test1[5] = "de";
              if (Object.getOwnPropertyNames(test1)[0] === "5") {
                return false;
              }

              // https://bugs.chromium.org/p/v8/issues/detail?id=3056
              var test2 = {};
              for (var i = 0; i < 10; i++) {
                test2["_" + String.fromCharCode(i)] = i;
              }
              var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
                return test2[n];
              });
              if (order2.join("") !== "0123456789") {
                return false;
              }

              // https://bugs.chromium.org/p/v8/issues/detail?id=3056
              var test3 = {};
              "abcdefghijklmnopqrst".split("").forEach(function (letter) {
                test3[letter] = letter;
              });
              if (
                Object.keys(Object.assign({}, test3)).join("") !==
                "abcdefghijklmnopqrst"
              ) {
                return false;
              }

              return true;
            } catch (err) {
              // We don't expect any of the above to throw, but better to be safe.
              return false;
            }
          }

          module.exports = shouldUseNative()
            ? Object.assign
            : function (target, source) {
                var from;
                var to = toObject(target);
                var symbols;

                for (var s = 1; s < arguments.length; s++) {
                  from = Object(arguments[s]);

                  for (var key in from) {
                    if (hasOwnProperty.call(from, key)) {
                      to[key] = from[key];
                    }
                  }

                  if (getOwnPropertySymbols) {
                    symbols = getOwnPropertySymbols(from);
                    for (var i = 0; i < symbols.length; i++) {
                      if (propIsEnumerable.call(from, symbols[i])) {
                        to[symbols[i]] = from[symbols[i]];
                      }
                    }
                  }
                }

                return to;
              };
        },
        {},
      ],
      7: [
        function (require, module, exports) {
          // shim for using process in browser
          var process = (module.exports = {});

          // cached from whatever global is present so that test runners that stub it
          // don't break things.  But we need to wrap it in a try catch in case it is
          // wrapped in strict mode code which doesn't define any globals.  It's inside a
          // function because try/catches deoptimize in certain engines.

          var cachedSetTimeout;
          var cachedClearTimeout;

          function defaultSetTimout() {
            throw new Error("setTimeout has not been defined");
          }
          function defaultClearTimeout() {
            throw new Error("clearTimeout has not been defined");
          }
          (function () {
            try {
              if (typeof setTimeout === "function") {
                cachedSetTimeout = setTimeout;
              } else {
                cachedSetTimeout = defaultSetTimout;
              }
            } catch (e) {
              cachedSetTimeout = defaultSetTimout;
            }
            try {
              if (typeof clearTimeout === "function") {
                cachedClearTimeout = clearTimeout;
              } else {
                cachedClearTimeout = defaultClearTimeout;
              }
            } catch (e) {
              cachedClearTimeout = defaultClearTimeout;
            }
          })();
          function runTimeout(fun) {
            if (cachedSetTimeout === setTimeout) {
              //normal enviroments in sane situations
              return setTimeout(fun, 0);
            }
            // if setTimeout wasn't available but was latter defined
            if (
              (cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) &&
              setTimeout
            ) {
              cachedSetTimeout = setTimeout;
              return setTimeout(fun, 0);
            }
            try {
              // when when somebody has screwed with setTimeout but no I.E. maddness
              return cachedSetTimeout(fun, 0);
            } catch (e) {
              try {
                // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
                return cachedSetTimeout.call(null, fun, 0);
              } catch (e) {
                // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
                return cachedSetTimeout.call(this, fun, 0);
              }
            }
          }
          function runClearTimeout(marker) {
            if (cachedClearTimeout === clearTimeout) {
              //normal enviroments in sane situations
              return clearTimeout(marker);
            }
            // if clearTimeout wasn't available but was latter defined
            if (
              (cachedClearTimeout === defaultClearTimeout ||
                !cachedClearTimeout) &&
              clearTimeout
            ) {
              cachedClearTimeout = clearTimeout;
              return clearTimeout(marker);
            }
            try {
              // when when somebody has screwed with setTimeout but no I.E. maddness
              return cachedClearTimeout(marker);
            } catch (e) {
              try {
                // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
                return cachedClearTimeout.call(null, marker);
              } catch (e) {
                // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
                // Some versions of I.E. have different rules for clearTimeout vs setTimeout
                return cachedClearTimeout.call(this, marker);
              }
            }
          }
          var queue = [];
          var draining = false;
          var currentQueue;
          var queueIndex = -1;

          function cleanUpNextTick() {
            if (!draining || !currentQueue) {
              return;
            }
            draining = false;
            if (currentQueue.length) {
              queue = currentQueue.concat(queue);
            } else {
              queueIndex = -1;
            }
            if (queue.length) {
              drainQueue();
            }
          }

          function drainQueue() {
            if (draining) {
              return;
            }
            var timeout = runTimeout(cleanUpNextTick);
            draining = true;

            var len = queue.length;
            while (len) {
              currentQueue = queue;
              queue = [];
              while (++queueIndex < len) {
                if (currentQueue) {
                  currentQueue[queueIndex].run();
                }
              }
              queueIndex = -1;
              len = queue.length;
            }
            currentQueue = null;
            draining = false;
            runClearTimeout(timeout);
          }

          process.nextTick = function (fun) {
            var args = new Array(arguments.length - 1);
            if (arguments.length > 1) {
              for (var i = 1; i < arguments.length; i++) {
                args[i - 1] = arguments[i];
              }
            }
            queue.push(new Item(fun, args));
            if (queue.length === 1 && !draining) {
              runTimeout(drainQueue);
            }
          };

          // v8 likes predictible objects
          function Item(fun, array) {
            this.fun = fun;
            this.array = array;
          }
          Item.prototype.run = function () {
            this.fun.apply(null, this.array);
          };
          process.title = "browser";
          process.browser = true;
          process.env = {};
          process.argv = [];
          process.version = ""; // empty string to avoid regexp issues
          process.versions = {};

          function noop() {}

          process.on = noop;
          process.addListener = noop;
          process.once = noop;
          process.off = noop;
          process.removeListener = noop;
          process.removeAllListeners = noop;
          process.emit = noop;
          process.prependListener = noop;
          process.prependOnceListener = noop;

          process.listeners = function (name) {
            return [];
          };

          process.binding = function (name) {
            throw new Error("process.binding is not supported");
          };

          process.cwd = function () {
            return "/";
          };
          process.chdir = function (dir) {
            throw new Error("process.chdir is not supported");
          };
          process.umask = function () {
            return 0;
          };
        },
        {},
      ],
      8: [
        function (require, module, exports) {
          (function (process) {
            /** @license React v16.8.1
             * react-is.development.js
             *
             * Copyright (c) Facebook, Inc. and its affiliates.
             *
             * This source code is licensed under the MIT license found in the
             * LICENSE file in the root directory of this source tree.
             */

            "use strict";

            if (process.env.NODE_ENV !== "production") {
              (function () {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });

                // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
                // nor polyfill, then a plain number is used for performance.
                var hasSymbol = typeof Symbol === "function" && Symbol.for;

                var REACT_ELEMENT_TYPE = hasSymbol
                  ? Symbol.for("react.element")
                  : 0xeac7;
                var REACT_PORTAL_TYPE = hasSymbol
                  ? Symbol.for("react.portal")
                  : 0xeaca;
                var REACT_FRAGMENT_TYPE = hasSymbol
                  ? Symbol.for("react.fragment")
                  : 0xeacb;
                var REACT_STRICT_MODE_TYPE = hasSymbol
                  ? Symbol.for("react.strict_mode")
                  : 0xeacc;
                var REACT_PROFILER_TYPE = hasSymbol
                  ? Symbol.for("react.profiler")
                  : 0xead2;
                var REACT_PROVIDER_TYPE = hasSymbol
                  ? Symbol.for("react.provider")
                  : 0xeacd;
                var REACT_CONTEXT_TYPE = hasSymbol
                  ? Symbol.for("react.context")
                  : 0xeace;
                var REACT_ASYNC_MODE_TYPE = hasSymbol
                  ? Symbol.for("react.async_mode")
                  : 0xeacf;
                var REACT_CONCURRENT_MODE_TYPE = hasSymbol
                  ? Symbol.for("react.concurrent_mode")
                  : 0xeacf;
                var REACT_FORWARD_REF_TYPE = hasSymbol
                  ? Symbol.for("react.forward_ref")
                  : 0xead0;
                var REACT_SUSPENSE_TYPE = hasSymbol
                  ? Symbol.for("react.suspense")
                  : 0xead1;
                var REACT_MEMO_TYPE = hasSymbol
                  ? Symbol.for("react.memo")
                  : 0xead3;
                var REACT_LAZY_TYPE = hasSymbol
                  ? Symbol.for("react.lazy")
                  : 0xead4;

                function isValidElementType(type) {
                  return (
                    typeof type === "string" ||
                    typeof type === "function" ||
                    // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
                    type === REACT_FRAGMENT_TYPE ||
                    type === REACT_CONCURRENT_MODE_TYPE ||
                    type === REACT_PROFILER_TYPE ||
                    type === REACT_STRICT_MODE_TYPE ||
                    type === REACT_SUSPENSE_TYPE ||
                    (typeof type === "object" &&
                      type !== null &&
                      (type.$$typeof === REACT_LAZY_TYPE ||
                        type.$$typeof === REACT_MEMO_TYPE ||
                        type.$$typeof === REACT_PROVIDER_TYPE ||
                        type.$$typeof === REACT_CONTEXT_TYPE ||
                        type.$$typeof === REACT_FORWARD_REF_TYPE))
                  );
                }

                /**
                 * Forked from fbjs/warning:
                 * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
                 *
                 * Only change is we use console.warn instead of console.error,
                 * and do nothing when 'console' is not supported.
                 * This really simplifies the code.
                 * ---
                 * Similar to invariant but only logs a warning if the condition is not met.
                 * This can be used to log issues in development environments in critical
                 * paths. Removing the logging code for production environments will keep the
                 * same logic and follow the same code paths.
                 */

                var lowPriorityWarning = function () {};

                {
                  var printWarning = function (format) {
                    for (
                      var _len = arguments.length,
                        args = Array(_len > 1 ? _len - 1 : 0),
                        _key = 1;
                      _key < _len;
                      _key++
                    ) {
                      args[_key - 1] = arguments[_key];
                    }

                    var argIndex = 0;
                    var message =
                      "Warning: " +
                      format.replace(/%s/g, function () {
                        return args[argIndex++];
                      });
                    if (typeof console !== "undefined") {
                      console.warn(message);
                    }
                    try {
                      // --- Welcome to debugging React ---
                      // This error was thrown as a convenience so that you can use this stack
                      // to find the callsite that caused this warning to fire.
                      throw new Error(message);
                    } catch (x) {}
                  };

                  lowPriorityWarning = function (condition, format) {
                    if (format === undefined) {
                      throw new Error(
                        "`lowPriorityWarning(condition, format, ...args)` requires a warning " +
                          "message argument"
                      );
                    }
                    if (!condition) {
                      for (
                        var _len2 = arguments.length,
                          args = Array(_len2 > 2 ? _len2 - 2 : 0),
                          _key2 = 2;
                        _key2 < _len2;
                        _key2++
                      ) {
                        args[_key2 - 2] = arguments[_key2];
                      }

                      printWarning.apply(undefined, [format].concat(args));
                    }
                  };
                }

                var lowPriorityWarning$1 = lowPriorityWarning;

                function typeOf(object) {
                  if (typeof object === "object" && object !== null) {
                    var $$typeof = object.$$typeof;
                    switch ($$typeof) {
                      case REACT_ELEMENT_TYPE:
                        var type = object.type;

                        switch (type) {
                          case REACT_ASYNC_MODE_TYPE:
                          case REACT_CONCURRENT_MODE_TYPE:
                          case REACT_FRAGMENT_TYPE:
                          case REACT_PROFILER_TYPE:
                          case REACT_STRICT_MODE_TYPE:
                          case REACT_SUSPENSE_TYPE:
                            return type;
                          default:
                            var $$typeofType = type && type.$$typeof;

                            switch ($$typeofType) {
                              case REACT_CONTEXT_TYPE:
                              case REACT_FORWARD_REF_TYPE:
                              case REACT_PROVIDER_TYPE:
                                return $$typeofType;
                              default:
                                return $$typeof;
                            }
                        }
                      case REACT_LAZY_TYPE:
                      case REACT_MEMO_TYPE:
                      case REACT_PORTAL_TYPE:
                        return $$typeof;
                    }
                  }

                  return undefined;
                }

                // AsyncMode is deprecated along with isAsyncMode
                var AsyncMode = REACT_ASYNC_MODE_TYPE;
                var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
                var ContextConsumer = REACT_CONTEXT_TYPE;
                var ContextProvider = REACT_PROVIDER_TYPE;
                var Element = REACT_ELEMENT_TYPE;
                var ForwardRef = REACT_FORWARD_REF_TYPE;
                var Fragment = REACT_FRAGMENT_TYPE;
                var Lazy = REACT_LAZY_TYPE;
                var Memo = REACT_MEMO_TYPE;
                var Portal = REACT_PORTAL_TYPE;
                var Profiler = REACT_PROFILER_TYPE;
                var StrictMode = REACT_STRICT_MODE_TYPE;
                var Suspense = REACT_SUSPENSE_TYPE;

                var hasWarnedAboutDeprecatedIsAsyncMode = false;

                // AsyncMode should be deprecated
                function isAsyncMode(object) {
                  {
                    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
                      hasWarnedAboutDeprecatedIsAsyncMode = true;
                      lowPriorityWarning$1(
                        false,
                        "The ReactIs.isAsyncMode() alias has been deprecated, " +
                          "and will be removed in React 17+. Update your code to use " +
                          "ReactIs.isConcurrentMode() instead. It has the exact same API."
                      );
                    }
                  }
                  return (
                    isConcurrentMode(object) ||
                    typeOf(object) === REACT_ASYNC_MODE_TYPE
                  );
                }
                function isConcurrentMode(object) {
                  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
                }
                function isContextConsumer(object) {
                  return typeOf(object) === REACT_CONTEXT_TYPE;
                }
                function isContextProvider(object) {
                  return typeOf(object) === REACT_PROVIDER_TYPE;
                }
                function isElement(object) {
                  return (
                    typeof object === "object" &&
                    object !== null &&
                    object.$$typeof === REACT_ELEMENT_TYPE
                  );
                }
                function isForwardRef(object) {
                  return typeOf(object) === REACT_FORWARD_REF_TYPE;
                }
                function isFragment(object) {
                  return typeOf(object) === REACT_FRAGMENT_TYPE;
                }
                function isLazy(object) {
                  return typeOf(object) === REACT_LAZY_TYPE;
                }
                function isMemo(object) {
                  return typeOf(object) === REACT_MEMO_TYPE;
                }
                function isPortal(object) {
                  return typeOf(object) === REACT_PORTAL_TYPE;
                }
                function isProfiler(object) {
                  return typeOf(object) === REACT_PROFILER_TYPE;
                }
                function isStrictMode(object) {
                  return typeOf(object) === REACT_STRICT_MODE_TYPE;
                }
                function isSuspense(object) {
                  return typeOf(object) === REACT_SUSPENSE_TYPE;
                }

                exports.typeOf = typeOf;
                exports.AsyncMode = AsyncMode;
                exports.ConcurrentMode = ConcurrentMode;
                exports.ContextConsumer = ContextConsumer;
                exports.ContextProvider = ContextProvider;
                exports.Element = Element;
                exports.ForwardRef = ForwardRef;
                exports.Fragment = Fragment;
                exports.Lazy = Lazy;
                exports.Memo = Memo;
                exports.Portal = Portal;
                exports.Profiler = Profiler;
                exports.StrictMode = StrictMode;
                exports.Suspense = Suspense;
                exports.isValidElementType = isValidElementType;
                exports.isAsyncMode = isAsyncMode;
                exports.isConcurrentMode = isConcurrentMode;
                exports.isContextConsumer = isContextConsumer;
                exports.isContextProvider = isContextProvider;
                exports.isElement = isElement;
                exports.isForwardRef = isForwardRef;
                exports.isFragment = isFragment;
                exports.isLazy = isLazy;
                exports.isMemo = isMemo;
                exports.isPortal = isPortal;
                exports.isProfiler = isProfiler;
                exports.isStrictMode = isStrictMode;
                exports.isSuspense = isSuspense;
              })();
            }
          }.call(this, require("_process")));
        },
        { _process: 7 },
      ],
      9: [
        function (require, module, exports) {
          /** @license React v16.8.1
           * react-is.production.min.js
           *
           * Copyright (c) Facebook, Inc. and its affiliates.
           *
           * This source code is licensed under the MIT license found in the
           * LICENSE file in the root directory of this source tree.
           */

          "use strict";
          Object.defineProperty(exports, "__esModule", { value: !0 });
          var b = "function" === typeof Symbol && Symbol.for,
            c = b ? Symbol.for("react.element") : 60103,
            d = b ? Symbol.for("react.portal") : 60106,
            e = b ? Symbol.for("react.fragment") : 60107,
            f = b ? Symbol.for("react.strict_mode") : 60108,
            g = b ? Symbol.for("react.profiler") : 60114,
            h = b ? Symbol.for("react.provider") : 60109,
            k = b ? Symbol.for("react.context") : 60110,
            l = b ? Symbol.for("react.async_mode") : 60111,
            m = b ? Symbol.for("react.concurrent_mode") : 60111,
            n = b ? Symbol.for("react.forward_ref") : 60112,
            p = b ? Symbol.for("react.suspense") : 60113,
            q = b ? Symbol.for("react.memo") : 60115,
            r = b ? Symbol.for("react.lazy") : 60116;
          function t(a) {
            if ("object" === typeof a && null !== a) {
              var u = a.$$typeof;
              switch (u) {
                case c:
                  switch (((a = a.type), a)) {
                    case l:
                    case m:
                    case e:
                    case g:
                    case f:
                    case p:
                      return a;
                    default:
                      switch (((a = a && a.$$typeof), a)) {
                        case k:
                        case n:
                        case h:
                          return a;
                        default:
                          return u;
                      }
                  }
                case r:
                case q:
                case d:
                  return u;
              }
            }
          }
          function v(a) {
            return t(a) === m;
          }
          exports.typeOf = t;
          exports.AsyncMode = l;
          exports.ConcurrentMode = m;
          exports.ContextConsumer = k;
          exports.ContextProvider = h;
          exports.Element = c;
          exports.ForwardRef = n;
          exports.Fragment = e;
          exports.Lazy = r;
          exports.Memo = q;
          exports.Portal = d;
          exports.Profiler = g;
          exports.StrictMode = f;
          exports.Suspense = p;
          exports.isValidElementType = function (a) {
            return (
              "string" === typeof a ||
              "function" === typeof a ||
              a === e ||
              a === m ||
              a === g ||
              a === f ||
              a === p ||
              ("object" === typeof a &&
                null !== a &&
                (a.$$typeof === r ||
                  a.$$typeof === q ||
                  a.$$typeof === h ||
                  a.$$typeof === k ||
                  a.$$typeof === n))
            );
          };
          exports.isAsyncMode = function (a) {
            return v(a) || t(a) === l;
          };
          exports.isConcurrentMode = v;
          exports.isContextConsumer = function (a) {
            return t(a) === k;
          };
          exports.isContextProvider = function (a) {
            return t(a) === h;
          };
          exports.isElement = function (a) {
            return "object" === typeof a && null !== a && a.$$typeof === c;
          };
          exports.isForwardRef = function (a) {
            return t(a) === n;
          };
          exports.isFragment = function (a) {
            return t(a) === e;
          };
          exports.isLazy = function (a) {
            return t(a) === r;
          };
          exports.isMemo = function (a) {
            return t(a) === q;
          };
          exports.isPortal = function (a) {
            return t(a) === d;
          };
          exports.isProfiler = function (a) {
            return t(a) === g;
          };
          exports.isStrictMode = function (a) {
            return t(a) === f;
          };
          exports.isSuspense = function (a) {
            return t(a) === p;
          };
        },
        {},
      ],
      10: [
        function (require, module, exports) {
          (function (process) {
            "use strict";

            if (process.env.NODE_ENV === "production") {
              module.exports = require("./cjs/react-is.production.min.js");
            } else {
              module.exports = require("./cjs/react-is.development.js");
            }
          }.call(this, require("_process")));
        },
        {
          "./cjs/react-is.development.js": 8,
          "./cjs/react-is.production.min.js": 9,
          _process: 7,
        },
      ],
    },
    {},
    [4]
  )(4);
});
